package com.demo.springai.model;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.Builder;

import java.time.LocalDateTime;
import java.util.Map;

/**
 * 聊天响应数据模型
 * 这个类用于返回AI的响应数据给客户端
 */
@Data  // Lombok注解：自动生成getter、setter、toString、equals、hashCode方法
@NoArgsConstructor  // 自动生成无参构造函数
@AllArgsConstructor  // 自动生成全参构造函数
@Builder  // 建造者模式，方便创建对象
public class ChatResponse {

    /**
     * AI回复的消息内容
     */
    @JsonProperty("message")
    private String message;

    /**
     * 响应状态
     * success: 成功
     * error: 失败
     * partial: 部分响应（流式响应中间状态）
     */
    @JsonProperty("status")
    private String status;

    /**
     * 使用的AI模型名称
     */
    @JsonProperty("model")
    private String model;

    /**
     * 响应生成时间
     */
    @JsonProperty("timestamp")
    private LocalDateTime timestamp;

    /**
     * 会话ID
     * 与请求中的会话ID对应
     */
    @JsonProperty("session_id")
    private String sessionId;

    /**
     * 消息ID
     * 唯一标识这条响应消息
     */
    @JsonProperty("message_id")
    private String messageId;

    /**
     * token使用情况统计
     */
    @JsonProperty("token_usage")
    private TokenUsage tokenUsage;

    /**
     * 错误信息（如果有）
     */
    @JsonProperty("error")
    private String error;

    /**
     * 错误代码（如果有）
     */
    @JsonProperty("error_code")
    private String errorCode;

    /**
     * 响应处理时间（毫秒）
     */
    @JsonProperty("processing_time_ms")
    private Long processingTimeMs;

    /**
     * 额外的元数据信息
     */
    @JsonProperty("metadata")
    private Map<String, Object> metadata;

    /**
     * Token使用情况的内部类
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public static class TokenUsage {
        /**
         * 输入token数（用户消息消耗的token）
         */
        @JsonProperty("prompt_tokens")
        private Integer promptTokens;

        /**
         * 输出token数（AI回复消耗的token）
         */
        @JsonProperty("completion_tokens")
        private Integer completionTokens;

        /**
         * 总token数
         */
        @JsonProperty("total_tokens")
        private Integer totalTokens;

        /**
         * 计算总token数
         */
        public void calculateTotal() {
            if (promptTokens != null && completionTokens != null) {
                totalTokens = promptTokens + completionTokens;
            }
        }
    }

    /**
     * 创建成功响应的静态方法
     *
     * @param message AI回复的消息
     * @param model   使用的模型
     * @return 成功的ChatResponse对象
     */
    public static ChatResponse success(String message, String model) {
        return ChatResponse.builder()
                .message(message)
                .status("success")
                .model(model)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 创建成功响应的静态方法（带会话ID）
     *
     * @param message   AI回复的消息
     * @param model     使用的模型
     * @param sessionId 会话ID
     * @return 成功的ChatResponse对象
     */
    public static ChatResponse success(String message, String model, String sessionId) {
        return ChatResponse.builder()
                .message(message)
                .status("success")
                .model(model)
                .sessionId(sessionId)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 创建错误响应的静态方法
     *
     * @param error     错误信息
     * @param errorCode 错误代码
     * @return 错误的ChatResponse对象
     */
    public static ChatResponse error(String error, String errorCode) {
        return ChatResponse.builder()
                .status("error")
                .error(error)
                .errorCode(errorCode)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 创建部分响应的静态方法（用于流式响应）
     *
     * @param partialMessage 部分消息内容
     * @param sessionId      会话ID
     * @return 部分响应的ChatResponse对象
     */
    public static ChatResponse partial(String partialMessage, String sessionId) {
        return ChatResponse.builder()
                .message(partialMessage)
                .status("partial")
                .sessionId(sessionId)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 检查响应是否成功
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return "success".equals(status);
    }

    /**
     * 检查响应是否是错误
     *
     * @return true if error
     */
    public boolean isError() {
        return "error".equals(status);
    }

    /**
     * 检查响应是否是部分响应
     *
     * @return true if partial
     */
    public boolean isPartial() {
        return "partial".equals(status);
    }

    /**
     * 设置token使用情况
     *
     * @param promptTokens     输入token数
     * @param completionTokens 输出token数
     */
    public void setTokenUsage(int promptTokens, int completionTokens) {
        this.tokenUsage = TokenUsage.builder()
                .promptTokens(promptTokens)
                .completionTokens(completionTokens)
                .totalTokens(promptTokens + completionTokens)
                .build();
    }

    /**
     * 设置处理时间
     *
     * @param startTime 开始时间（毫秒）
     */
    public void setProcessingTime(long startTime) {
        this.processingTimeMs = System.currentTimeMillis() - startTime;
    }
}
